{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "using ValidatedNumerics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "split (generic function with 12 methods)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import Base.split\n",
    "\n",
    "function split{T<:Real}(x::Interval{T}, n::Integer)\n",
    "    \n",
    "    width = diam(x) / n\n",
    "    \n",
    "    intervals = [Interval(x.lo + width*i, x.lo + width*(i+1)) for i in 0:n-1]\n",
    "    \n",
    "end\n",
    "\n",
    "function split{T<:Real}(X::IntervalBox{2,T}, n::Integer, m::Integer=n)\n",
    "    x, y = X\n",
    "        \n",
    "    x_intervals = split(x, m)\n",
    "    y_intervals = split(y, n)\n",
    "    \n",
    "    boxes = IntervalBox{2,T}[]\n",
    "    \n",
    "    for i in x_intervals, j in y_intervals\n",
    "        push!(boxes, IntervalBox(i, j))\n",
    "    end\n",
    "    \n",
    "    boxes\n",
    "    \n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9-element Array{ValidatedNumerics.IntervalBox{2,Float64},1}:\n",
       " IntervalBox([0.0, 0.3333333333333333],[0.0, 0.3333333333333333])                              \n",
       " IntervalBox([0.0, 0.3333333333333333],[0.3333333333333333, 0.6666666666666666])               \n",
       " IntervalBox([0.0, 0.3333333333333333],[0.6666666666666666, 1.0])                              \n",
       " IntervalBox([0.3333333333333333, 0.6666666666666666],[0.0, 0.3333333333333333])               \n",
       " IntervalBox([0.3333333333333333, 0.6666666666666666],[0.3333333333333333, 0.6666666666666666])\n",
       " IntervalBox([0.3333333333333333, 0.6666666666666666],[0.6666666666666666, 1.0])               \n",
       " IntervalBox([0.6666666666666666, 1.0],[0.0, 0.3333333333333333])                              \n",
       " IntervalBox([0.6666666666666666, 1.0],[0.3333333333333333, 0.6666666666666666])               \n",
       " IntervalBox([0.6666666666666666, 1.0],[0.6666666666666666, 1.0])                              "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = IntervalBox(0..1, 0..1)\n",
    "\n",
    "\n",
    "input = split(X, 3)\n",
    "input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(xx::IntervalBox) = ((x,y)=xx; IntervalBox(2x + y, x + y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9-element Array{ValidatedNumerics.IntervalBox{2,Float64},1}:\n",
       " IntervalBox([0.0, 1.0],[0.0, 0.6666666666666666])                                             \n",
       " IntervalBox([0.3333333333333333, 1.3333333333333333],[0.3333333333333333, 1.0])               \n",
       " IntervalBox([0.6666666666666666, 1.6666666666666667],[0.6666666666666666, 1.3333333333333335])\n",
       " IntervalBox([0.6666666666666666, 1.6666666666666667],[0.3333333333333333, 1.0])               \n",
       " IntervalBox([0.9999999999999999, 2.0],[0.6666666666666666, 1.3333333333333333])               \n",
       " IntervalBox([1.3333333333333333, 2.3333333333333335],[0.9999999999999999, 1.6666666666666667])\n",
       " IntervalBox([1.3333333333333333, 2.3333333333333335],[0.6666666666666666, 1.3333333333333335])\n",
       " IntervalBox([1.6666666666666665, 2.666666666666667],[0.9999999999999999, 1.6666666666666667]) \n",
       " IntervalBox([1.9999999999999998, 3.0],[1.3333333333333333, 2.0])                              "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output = map(f, input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "draw (generic function with 4 methods)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "include(\"draw_function_image.jl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqkAAAHRCAYAAABJvyD2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIABJREFUeJzt3X2M1fWd9//XGYaBYRBUbgQ0SKtQu9oWISiLrlGTDd6ENnVFSmtbvdrQ3W1javfnzXa3IQ1psjXbmrhedi9NSkEJ64q6ba1Ze9nWxO1SqkLXX28oshbdynArIDA3zM35/WGZ/Cg3zsDMnI/weCQk9TPf75z3OV8/8uw5c85UqtVqNQAAUJC6Wg8AAAB/TKQCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFCcXkfqCy+8kC984Qu58MILM3LkyJx77rlZsGBBXnnllV6dv3v37ixatCjjxo3LyJEjc/XVV2fdunXHPTgAACevSrVarfbmwBtvvDGrV6/O/Pnz88EPfjDNzc25//77s2/fvvzsZz/LhRdeeNRzu7u782d/9md5+eWXc+edd2bMmDF54IEH8j//8z956aWXcv755/fbHQIA4N2v15G6evXqzJo1K/X19T1rGzduzAc+8IHceOONefjhh4967r/+67/mYx/7WFatWpUbbrghSbJjx45MmzYt1157bVasWHGCdwMAgJNJryP1aGbOnJm6urq88MILRz3mpptuyn/8x39k8+bNh6z/5V/+ZR555JHs2rUrQ4cOPZExAAA4iZzQG6eq1Wq2bt2asWPHHvO4devWZcaMGYetz5o1Ky0tLdmwYcOJjAEAwEnmhCJ1xYoV2bx5cxYsWHDM45qbmzNx4sTD1g+u/fEzrAAAnNrq3/mQI1u/fn0+//nPZ86cOfn0pz99zGPb2toybNiww9aHDx+eJGltbT3ieTt27MgzzzyTKVOmpLGx8XhHBQBggLS2tmbTpk2ZO3fuO7663hfHFalbtmzJ9ddfnzPOOCOrVq1KpVI55vGNjY1pb28/bL2tra3n60fyzDPP5Oabbz6eEQEAGESPPPJIPvGJT/Tb9+tzpO7ZsyfXXntt3nrrrTz//POZMGHCO54zceLEI76k39zcnCSZNGnSEc+bMmVKkrfv9Pvf//6+jsoAu/3223PvvffWegyOwLUpm+tTpu3bt+fTixbl8nvuyfDTT6/1OPyR5xYvzpVf/Wqtx+AImtety4//9m97uq2/9ClS29raMm/evGzcuDHPPvtsLrjggl6dN3369Dz//POpVquHPOu6Zs2aNDU1Zdq0aUc87+AzrO9///uP+MYramv06NGuS6Fcm7K5PmVqbm7O0OHDc+4VV+S0I7yPgtp64X//75w/d26tx+AY+vtHM3v9xqmurq4sWLAga9asyWOPPZZLL730iMdt2bIl69evT2dnZ8/ajTfemK1bt+aJJ57oWduxY0cee+yxzJs3z8dPAQBwiF4/k/o3f/M3+f73v5958+Zlx44deeSRRw75+sGfHb377ruzfPnybNq0KZMnT07ydqTOnj07t956a37961/3/MaparWar3rqHgCAP9LrSP2v//qvVCqVfP/738/3v//9Q75WqVR6IrVSqRz2Rqq6uro8/fTTueOOO3LfffeltbU1l1xySZYvX56pU6f2w90AAOBk0uuX+3/yk5+kq6sr3d3dh/3p6urqOW7p0qXp6urqeRb1oNNPPz0PPfRQtm/fnn379uXHP/6xn8l6l1u4cGGtR+AoXJuyuT7les9FF9V6BI7iIvvmlHNCH+bPqc1ftOVybcrm+pTrvR/4QK1H4Cg+YN+cckQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAceprPQDAYNi5c2cOHDhQ6zGK8uabb6ajo6PWYxRj+/btefPNN9O1bVv2Vyq1HqcYdXV1aWxsrPUYRRkyZEhGjBhR6zFOeiIVOOnt3LkzS/7pn7K71oMUpK2lJS+//HIODB9e61GK0dnWlp0tLRnyn/+ZujPOqPU4xRiS5KyxY1NfLxkOGp7kiksuEaoDzL9xwEnvwIED2Z2k8YYbMmLcuFqPU4R9W7emkmTERz+aoWPH1nqcInRs25a9jz+eIVdckSETJtR6nCJ0d3ame+fODDvrrDQ0NNR6nCJ0tLSk7Te/SVdXV61HOemJVOCUMWLcuJw2cWKtxyjG0BEj0jhlSoZ5TJIk7SNHZuioUak/88zUjxlT63GK0Nnens7W1jSMHJlhw4bVepxidNZ6gFOEN04BAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUp0+Run///ixevDjXXHNNzjzzzNTV1WXZsmW9Ovc73/lO6urqjvhn27ZtxzU8AAAnp/q+HLx9+/YsWbIk5557bqZPn57nnnsulUqlTze4ZMmSvOc97zlkbfTo0X36HgAAnNz6FKmTJk3Kli1bMn78+Lz00kuZNWtWn2/w2muvzYwZM/p8HgAAp44+vdzf0NCQ8ePHJ0mq1epx3WC1Ws3evXvT1dV1XOcDAHDyG/Q3Tl111VUZPXp0mpqa8pGPfCQbN24c7BEAAChcn17uPxFNTU259dZbc9VVV2XUqFF58cUX881vfjNz5szJ2rVrc8455wzWKAAAFG7QInX+/PmZP39+zz9/+MMfzty5c3PFFVfka1/7Wr71rW8N1igAABRu0CL1SC677LJceumlefbZZ4953O23337YJwAsXLgwCxcuHMjxAAD4//l/V67ML1euPGRt/wB9lGhNIzVJzjnnnGzYsOGYx9x7770+EQAAoMY+sHBhPvBHTxJufOaZrLjmmn6/rZr/xqlXX30148aNq/UYAAAUZEAidcuWLVm/fn06Ozt71rZv337YcU8//XTWrl2bawagvgEAePfq88v9999/f3bv3p3NmzcnSb73ve/l9ddfT5LcdtttGTVqVO6+++4sX748mzZtyuTJk5Mkc+bMyYwZMzJz5syMHj06a9euzbe//e1Mnjw5X/7yl/vxLgEA8G7X50j9xje+kddeey1JUqlU8uSTT+aJJ55IpVLJpz71qYwaNSqVSuWwX5f6sY99LD/4wQ/ywx/+MC0tLZk0aVI+97nPZfHixV7uBwDgEH2O1N/97nfveMzSpUuzdOnSQ9aWLFmSJUuW9PXmAAA4BdX8jVMAAPDHRCoAAMURqQAAFEekAgBQHJEKAEBxRCoAAMURqQAAFEekAgBQHJEKAEBxRCoAAMURqQAAFEekAgBQHJEKAEBxRCoAAMURqQAAFEekAgBQHJEKAEBxRCoAAMURqQAAFEekAgBQHJEKAEBxRCoAAMURqQAAFEekAgBQHJEKAEBxRCoAAMURqQAAFKe+1gNAf9i5c2cOHDhQ6zGK8eabb6ajo6PWYxRj+/bt2fLGG9n7q19lxLZttR6nCC3bt2fvrl3pfvPNHGhoqPU4Reh48810tLen+sYb6Wpvr/U4Rejq7EzX9u05kCTDhtV6nCIc2LcvHTt3Zt+WLcm+fbUepwhtu3cPyPcVqbzr7dy5M0v+6Z8yMFvk3aetpSUvv/xyDgwfXutRitH+1lvZsnVrKnv3+ov2D6otLel6880MffHF1I0ZU+txilB96610vvFG6h96KJVKpdbjFKG7uztpbc2+SZPS2NhY63GK0NHSkvYNG7Jr2rS0jxhR63GK0N7cPCDfV6TyrnfgwIHsTtJ4ww0ZMW5crcepuX1bt6aSZMRHP5qhY8fWepwitPz616n7P/8ndZ/7XCqTJ9d6nCJUt25N96OPZsisWambNKnW4xSh2t2dygc/mNPq6zNkyJBaj1OEjj170vnCC7lkzpyMHz++1uMUYd/Wrdn18MP58sc/nrPOOqvW4xTh5ZdfzlMPPtjv31ekctIYMW5cTps4sdZjFGHoiBFpnDIlwzweb9u/P3UNDRlyzjmpP++8Wk9ThM6GhlSamlI3enTqTz+91uMUobuzM5W6ujSMHJn6en89Jkl27kz3xo1pOuusnDZhQq2nKUb7aaflrLPOykT/jU2SNA/QM6neOAUAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUR6QCAFAckQoAQHFEKgAAxRGpAAAUp0+Run///ixevDjXXHNNzjzzzNTV1WXZsmW9Pn/37t1ZtGhRxo0bl5EjR+bqq6/OunXr+jw0AAAntz5F6vbt27NkyZL89re/zfTp05MklUqlV+d2d3fn+uuvz8qVK3PbbbflnnvuybZt23LllVdm48aNfZ8cAICTVn1fDp40aVK2bNmS8ePH56WXXsqsWbN6fe6qVauyevXqrFq1KjfccEOS5Kabbsq0adOyePHirFixom+TAwBw0urTM6kNDQ0ZP358kqRarfbphlatWpUJEyb0BGqSjB07NjfddFO++93vpqOjo0/fDwCAk9egvXFq3bp1mTFjxmHrs2bNSktLSzZs2DBYowAAULhBi9Tm5uZMnDjxsPWDa5s3bx6sUQAAKFyffib1RLS1tWXYsGGHrQ8fPjxJ0traetRzX3nllQwdOnTAZnu3efXVV3PaaafVeoxi7Ny5M6/8139lx//9v2k888xaj1NzrW++mT2vv57uN9/MgYaGWo9ThJbdu9Pd1ZXKvn3p3L271uMUoXvv3lQ7OtK9eXM6/bhVkqS7qyvV1tYcaGxM15AhtR6nCB1vvZXuXbuyf+vW7O3jj/mdrFq2b6/1CKeMQYvUxsbGtLe3H7be1tbW8/Wj+cQnPnHYpwgMHTr0lAzXrq6u7N+/P/UNDend5yqc/Lq7u9PV2Zk89VTSy0+bOBU0/MmfpO6CC2o9RhG6X3stB1paUvfyy6m88UatxylC9549qTY3p+uhh1Kt85HZydv/Lam2t+fAsGGp85gkSbrb2lJ99dW8tX59hpxxRq3HKcbpeft9OqeilStXZuXKlYes7dmzZ0Bua9AideLEiUd8Sb+5uTnJ258ccDSNjY09z7ie6g5GfWXo0NQf4ZnpU1FHa2vS2Zk0NKTi35OkoyPV9vZUpk3LkMsvr/U0Rai8972p27Ahw2bOTN0RfuzoVNTd3p6u8ePz3vHjM2LEiFqPU4SOlpa0/epXufTCCz0mf9CybVveWrkyX7311px11lm1HqcYDQ0NGTNmTK3HqImFCxdm4cKFh6ytXbs2M2fO7PfbGrRInT59ep5//vlUq9VDnhVds2ZNmpqaMm3atKOeW19ff0o+a3okBw4cSJLU1ddniEhNknQdfKmyvj51HpN0J0l7e4aMHJn600+v9ThF6Ny7N5WmptSdcUbqT9G/WP5YZ0tLqhMnpmnKlIwcObLW4xShfe/e1O3alfHvfa8fqfqDvSNHZsjYsTnrrLOO+L4SGEgD8nrGli1bsn79+nR2dvas3Xjjjdm6dWueeOKJnrUdO3bksccey7x580QoAAA9+vxM6v3335/du3f3vHT/ve99L6+//nqS5LbbbsuoUaNy9913Z/ny5dm0aVMmT56c5O1InT17dm699db8+te/zpgxY/LAAw+kWq3mq1/9aj/eJQAA3u36HKnf+MY38tprryV5+1eiPvnkk3niiSdSqVTyqU99KqNGjUqlUjnsjU51dXV5+umnc8cdd+S+++5La2trLrnkkixfvjxTp07tn3sDAMBJoc+R+rvf/e4dj1m6dGmWLl162Prpp5+ehx56KA899FBfbxYAgFOIz9gAAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA4IhUAgOKIVAAAiiNSAQAojkgFAKA49bUeoDfa29tTrVZrPUYROjo6kiRdBw4klUqNpylD1x8ek3R0pKulpbbDlKCzM6lW071tWzo3bar1NEXoam5Odf/+dL36arr37q31OEWoHjiQ7jfeyP6urlRHjKj1OEXobG1N586d2bdlS7JvX63HKULL9u21HoFT2LsiUltbW9Pa2lrrMYrS2dqaTo/JoVpb3/5DkqRrxYrkuedqPUYRulpaUn3llXT95jf+z91BXV2p7t2bfWeemY5hw2o9TTEakuy54IK0Dx9e61GKcXqShoaGWo/BKehdEalDhg9PvQ2SJOk8cCBdbW2pNDamzmOSJOk+cCDV1taksTEZOrTW49Red3fS2Zkp/+t/5bSLLqr1NEXoaGnJ/p/9LNPPOy8jGhtrPU4RWnbsyL5/+7f8Px//eMaNG1frcYoxdOjQnHnmmbUeoygNDQ0ZM2ZMrcfgFPSuiNT6hoYMbWqq9RjF6GprS11DQ4Z4ie5t1Wq6WltTaWhIncck3R0dSVtbGidPzmlTp9Z6nCK0792bul27MmXmzJx22mm1HqcIe5ubs3Pdulx00UWZOHFirccBOIw3TgEAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABSnT5Ha3t6eu+66K5MmTcqIESMye/bsPPvss+943ne+853U1dUd8c+2bduOe3gAAE5O9X05+JZbbsnjjz+e22+/PVOnTs3SpUtz3XXX5Sc/+Ukuu+yydzx/yZIlec973nPI2ujRo/s2MQAAJ71eR+rPf/7zPProo/nHf/zHfOlLX0qSfPKTn8xFF12UO++8Mz/96U/f8Xtce+21mTFjxvFPCwDAKaHXL/evWrUq9fX1WbRoUc/asGHD8pnPfCarV6/OG2+88Y7fo1qtZu/evenq6jq+aQEAOCX0OlLXrVuXadOmZeTIkYesz5o1K0nyi1/84h2/x1VXXZXRo0enqakpH/nIR7Jx48Y+jgsAwKmg1y/3Nzc3Z+LEiYetH1zbvHnzUc9tamrKrbfemquuuiqjRo3Kiy++mG9+85uZM2dO1q5dm3POOec4RgcA4GTV60htbW3NsGHDDlsfPnx4z9ePZv78+Zk/f37PP3/4wx/O3Llzc8UVV+RrX/tavvWtb/VlZgAATnK9jtTGxsa0t7cftt7W1tbz9b647LLLcumll/bqI6w6WlrS+Ue3Xd/YmKF9vE0AAI7fypUrs3LlykPW9uzZMyC31etInThx4hFf0m9ubk6STJo0qc83fs4552TDhg3veNzQESMytKmpz98fAID+s3DhwixcuPCQtbVr12bmzJn9flu9fuPUxRdfnA0bNmTv3r2HrK9ZsyZJMn369D7f+Kuvvppx48b1+TwAAE5uvY7UG2+8MV1dXXnwwQd71trb27N06dLMnj07Z599dpJky5YtWb9+fTo7O3uO2759+2Hf7+mnn87atWtzzTXXnMj8AACchHr9cv8ll1yS+fPn52//9m+zbdu2nHfeeVm2bFlef/31LF26tOe4u+++O8uXL8+mTZsyefLkJMmcOXMyY8aMzJw5M6NHj87atWvz7W9/O5MnT86Xv/zl/r9XAAC8q/Xp16IuX748X/nKV/Lwww9n165d+dCHPpSnnnoql19+ec8xlUollUrlkPM+9rGP5Qc/+EF++MMfpqWlJZMmTcrnPve5LF682Mv9AAAcpk+ROmzYsNxzzz255557jnrM0qVLD3lmNUmWLFmSJUuWHN+EAACccnr9M6kAADBYRCoAAMURqQAAFEekAgBQHJEKAEBxRCoAAMURqQAAFEekAgBQHJEKAEBxRCoAAMURqQAAFEekAgBQHJEKAEBxRCoAAMURqQAAFEekAgBQHJEKAEBxRCoAAMURqQAAFEekAgBQHJEKAEBxRCoAAMURqQAAFEekAgBQHJEKAEBxRCoAAMURqQAAFKe+1gP0RldHRyptbbUeowhdHR1JkuqBA+mq8Syl6D74mLS3p6tarfE0BejqSrq70/r666kfNarW0xShs7U1nTt3Zt+WLcm+fbUepwgt27fXegSAY3pXRGpna2s6W1trPUZRultbE4/Jodra3v5DkmTPPfek+6yzaj1GMRqS7LnggrQPH17rUYpxepKGhoZajwFwRO+KSK1vbMyQYcNqPUYRug4cSGdLy9uPydChtR6nCF0dHelsbU19Y2Pq6t8V/0oPqO7OzlQ7OrLk1ltzySWX1HqcYgwdOjRnnnlmrccoSkNDQ8aMGVPrMQCO6F3xN/qQoUMztLGx1mMUo7OlJfXDh6feM0Jv+8Mz7R6Tt3W1t6ezqyvnn39+pk+fXutxAOC4eOMUAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABSnT5Ha3t6eu+66K5MmTcqIESMye/bsPPvss706d/fu3Vm0aFHGjRuXkSNH5uqrr866deuOa2gAAE5ufYrUW265Jffee28++clP5r777suQIUNy3XXX5ac//ekxz+vu7s7111+flStX5rbbbss999yTbdu25corr8zGjRtP6A5QOx2trbUegaPo7uqq9Qgcw8qVK2s9Akfh2pTLtTn19DpSf/7zn+fRRx/NP/zDP+TrX/96PvvZz+bHP/5xzj333Nx5553HPHfVqlVZvXp1li1blq985Sv567/+6zz33HMZMmRIFi9efMJ3gtroFKnF6u7urvUIHIO/bMvl2pTLtTn19DpSV61alfr6+ixatKhnbdiwYfnMZz6T1atX54033jjmuRMmTMgNN9zQszZ27NjcdNNN+e53v5uOjo7jHB8AgJNRryN13bp1mTZtWkaOHHnI+qxZs5Ikv/jFL4557owZMw5bnzVrVlpaWrJhw4bejgEAwCmg15Ha3NyciRMnHrZ+cG3z5s0Dci4AAKee+t4e2NrammHDhh22Pnz48J6vH01bW9txnXtwvfPAgd6OedLr+sOPRnS2taVa4zfHVLu60rF/f01nSMp6TErQ9YfHYMOGDTn99NNrPA1HsmfPnqxdu7bWY3AErk25XJty/eY3v0ly7BY8Hr2O1MbGxrS3tx+23tbW1vP1/j5306ZNSZKutrZ0/eFY3tbZ2lrEG5fa33qr1iP0KOUxKcVf/dVf1XoEjmHmzJm1HoGjcG3K5dqUbdOmTbnsssv67fv1OlInTpx4xJflm5ubkySTJk3q93Pnzp2bRx55JFOmTDlmBAMAUButra3ZtGlT5s6d26/ft9eRevHFF+e5557L3r17c9ppp/Wsr1mzJkkyffr0o547ffr0PP/886lWq6lUKoec29TUlGnTph3xvLFjx+YTn/hEb0cEAKAG+vMZ1IN6/capG2+8MV1dXXnwwQd71trb27N06dLMnj07Z599dpJky5YtWb9+fTo7Ow85d+vWrXniiSd61nbs2JHHHnss8+bNy9ChQ/vjvgAAcJKoVKvVam8PXrBgQZ588sncfvvtOe+887Js2bK8+OKL+dGPfpTLL788ydu/lWr58uXZtGlTJk+enOTtDxa//PLL88tf/jJ33HFHxowZkwceeCC///3v88ILL2Tq1KkDc+8AAHhX6vXL/UmyfPnyfOUrX8nDDz+cXbt25UMf+lCeeuqpnkBNkkrNpxrpAAAIkElEQVSlcshL+klSV1eXp59+OnfccUfuu+++tLa25pJLLsny5csFKgAAh+nTM6kAADAYev0zqQAAMFhqEqnt7e256667MmnSpIwYMSKzZ8/Os88+26tzd+/enUWLFmXcuHEZOXJkrr766qxbt26AJz51HO+1+c53vpO6uroj/tm2bdsgTH7y279/fxYvXpxrrrkmZ555Zurq6rJs2bJen2/vDJwTuTb2zsB64YUX8oUvfCEXXnhhRo4cmXPPPTcLFizIK6+80qvz7ZuBdSLXx94ZWL/61a8yf/78nHfeeWlqasqYMWMyZ86crFixolfn98fe6dPPpPaXW265JY8//nhuv/32TJ06NUuXLs11112Xn/zkJ8f8CIPu7u5cf/31efnll3PnnXf2vAHryiuvzEsvvZTzzz9/EO/Fyel4r81BS5YsyXve855D1kaPHj1Q455Stm/fniVLluTcc8/N9OnT89xzzx32899HY+8MrBO5NgfZOwPj61//elavXp358+fngx/8YJqbm3P//fdnxowZ+dnPfpYLL7zwqOfaNwPvRK7PQfbOwHj99dezb9++3HLLLZk0aVJaWlqyatWqfPKTn8ymTZvyd3/3d0c9t9/2TnWQrVmzplqpVKrf+MY3etba2tqq559/fnXOnDnHPPfRRx+tViqV6uOPP96ztn379uoZZ5xR/fjHPz5gM58qTuTaLF26tFqpVKovvfTSQI95ympvb69u3bq1Wq1Wqy+++GK1UqlUly1b1qtz7Z2BdSLXxt4ZWP/5n/9Z7ejoOGTtlVdeqQ4fPrx68803H/Nc+2bgncj1sXcGX1dXV3X69OnVyZMnH/O4/to7g/5y/6pVq1JfX59Fixb1rA0bNiyf+cxnsnr16rzxxhvHPHfChAm54YYbetbGjh2bm266Kd/97nfT8Yff4c7xOZFrc1C1Ws3evXt7fn88/aehoSHjx49P8vbj3Bf2zsA6kWtzkL0zMP70T/809fWHvmh4/vnn50/+5E+yfv36Y55r3wy8E7k+B9k7g6euri7nnHPOO36+fX/tnUGP1HXr1mXatGkZOXLkIeuzZs1KkvziF7845rkzZsw4bH3WrFlpaWnJhg0b+nfYU8yJXJuDrrrqqowePTpNTU35yEc+ko0bNw7IrPSNvVM+e2fwVKvVbN26NWPHjj3mcfZNbfT2+hxk7wyslpaW7NixI//93/+de++9N88880zuvPPOY57TX3tn0CO1ubk5EydOPGz94NrmzZsH5Fze2Yk8vk1NTbn11lvzwAMP5N/+7d9y55135kc/+lHmzJmT3//+9wM2M71j75TL3hl8K1asyObNm7NgwYJjHmff1EZvr4+9Mzi+9KUvZfz48Zk6dWruuuuu3HfffYe84nok/bV3Bv2NU62trRk2bNhh68OHD+/5+tG0tbUd97m8sxO5NvPnz8/8+fN7/vnDH/5w5s6dmyuuuCJf+9rX8q1vfav/B6bX7J1y2TuDa/369fn85z+fOXPm5NOf/vQxj7VvBl9fro+9Mzhuv/323HTTTdm8eXNWrFiRL3zhC2lsbDzm9emvvTPokdrY2Jj29vbD1tva2nq+PhDn8s76+/G97LLLcumll/b648UYOPbOu4u9MzC2bNmS66+/PmeccUZWrVr1jp/AYN8Mrr5enyOxd/rf+973vrzvfe9Lktx8882ZO3duvvjFL+amm2466h7or70z6C/3T5w48YhP8zY3NydJJk2aNCDn8s4G4vE955xzsmvXrhOejRNj77z72Dv9a8+ePbn22mvz1ltv5d///d8zYcKEdzzHvhk8x3N9jsbeGVh/8Rd/kT179uS3v/3tUY/pr70z6JF68cUXZ8OGDdm7d+8h62vWrEmSTJ8+/ajnTp8+PWvXrj3s3bNr1qxJU1NTpk2b1v8Dn0JO5Noczauvvppx48b1y3wcP3vn3cfe6T9tbW2ZN29eNm7cmKeeeioXXHBBr86zbwbH8V6fo7F3BtbBl+rr6o6ekP21dwY9Um+88cZ0dXXlwQcf7Flrb2/P0qVLM3v27Jx99tlJ3n7af/369ens7Dzk3K1bt+aJJ57oWduxY0cee+yxzJs37x0/EoFjO5Frs3379sO+39NPP521a9fmmmuuGfjh6WHvlMveGXxdXV1ZsGBB1qxZk8ceeyyXXnrpEY+zb2rjRK6PvTOwjvT4dnR0ZPny5RkzZkzPL1pobm4esL1TqR7vh/qdgAULFuTJJ5/M7bffnvPOOy/Lli3Liy++mB/96Ee5/PLLk7z9m4+WL1+eTZs2ZfLkyUne/g0Gl19+eX75y1/mjjvu6PkNBr///e/zwgsvZOrUqYN9V046x3ttpk6dmhkzZmTmzJkZPXp01q5dm29/+9s5++yz88ILL/h/tf3k/vvvz+7du7N58+b88z//c2644YaeZ7hvu+22jBo1yt6pkeO9NvbOwPriF7+Y++67L/PmzTvkTTYH3XzzzUn8nVMrJ3J97J2B9dGPfjR79+7NFVdckUmTJmXLli1ZsWJFNmzYkKVLl+ZTn/pUkgHeO335TQP9pa2trXrHHXdUJ06cWB0+fHj10ksvrf7whz885JhbbrmlWldXV33ttdcOWd+1a1f1s5/9bHXs2LHVpqam6lVXXeW3TfSj4702f//3f1+9+OKLq6effnq1oaGhOmXKlOrnP//56rZt2wb7LpzUpkyZUq1UKtVKpVKtq6ur1tXV9fzvg9fD3qmN47029s7AuvLKK3uuxR//qaur6znOvqmNE7k+9s7A+pd/+Zfqn//5n1cnTJhQHTp0aHXMmDHV6667rvrss88ectxA7p2aPJMKAADHMug/kwoAAO9EpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADFEakAABRHpAIAUByRCgBAcUQqAADF+f8Aan5uMyZ/wFsAAAAASUVORK5CYII=",
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x31b268d10>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(0.0,3.0,0.0,2.0)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "draw(output, \"cyan\")\n",
    "draw(input, \"black\", 0.9)\n",
    "\n",
    "axis(\"image\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script charset=\"utf-8\">(function ($, undefined) {\n",
       "\n",
       "    function createElem(tag, attr, content) {\n",
       "\t// TODO: remove jQuery dependency\n",
       "\tvar el = $(\"<\" + tag + \"/>\").attr(attr);\n",
       "\tif (content) {\n",
       "\t    el.append(content);\n",
       "\t}\n",
       "\treturn el[0];\n",
       "    }\n",
       "\n",
       "    // A widget must expose an id field which identifies it to the backend,\n",
       "    // an elem attribute which is will be added to the DOM, and\n",
       "    // a getState() method which returns the value to be sent to the backend\n",
       "    // a sendUpdate() method which sends its current value to the backend\n",
       "    var Widget = {\n",
       "\tid: undefined,\n",
       "\telem: undefined,\n",
       "\tlabel: undefined,\n",
       "\tgetState: function () {\n",
       "\t    return this.elem.value;\n",
       "\t},\n",
       "\tsendUpdate: undefined\n",
       "    };\n",
       "\n",
       "    var Slider = function (typ, id, init) {\n",
       "\tvar attr = { type:  \"range\",\n",
       "\t\t     value: init.value,\n",
       "\t\t     min:   init.min,\n",
       "\t\t     max:   init.max,\n",
       "\t\t     step:  init.step },\n",
       "\t    elem = createElem(\"input\", attr),\n",
       "\t    self = this;\n",
       "\n",
       "\telem.onchange = function () {\n",
       "\t    self.sendUpdate();\n",
       "\t}\n",
       "\n",
       "\tthis.id = id;\n",
       "\tthis.elem = elem;\n",
       "\tthis.label = init.label;\n",
       "\n",
       "\tInputWidgets.commInitializer(this); // Initialize communication\n",
       "    }\n",
       "    Slider.prototype = Widget;\n",
       "\n",
       "    var Checkbox = function (typ, id, init) {\n",
       "\tvar attr = { type: \"checkbox\",\n",
       "\t\t     checked: init.value },\n",
       "\t    elem = createElem(\"input\", attr),\n",
       "\t    self = this;\n",
       "\n",
       "\tthis.getState = function () {\n",
       "\t    return elem.checked;\n",
       "\t}\n",
       "\telem.onchange = function () {\n",
       "\t    self.sendUpdate();\n",
       "\t}\n",
       "\n",
       "\tthis.id = id;\n",
       "\tthis.elem = elem;\n",
       "\tthis.label = init.label;\n",
       "\n",
       "\tInputWidgets.commInitializer(this);\n",
       "    }\n",
       "    Checkbox.prototype = Widget;\n",
       "\n",
       "    var Button = function (typ, id, init) {\n",
       "\tvar attr = { type:    \"button\",\n",
       "\t\t     value:   init.label },\n",
       "\t    elem = createElem(\"input\", attr),\n",
       "\t    self = this;\n",
       "\tthis.getState = function () {\n",
       "\t    return null;\n",
       "\t}\n",
       "\telem.onclick = function () {\n",
       "\t    self.sendUpdate();\n",
       "\t}\n",
       "\n",
       "\tthis.id = id;\n",
       "\tthis.elem = elem;\n",
       "\tthis.label = init.label;\n",
       "\n",
       "\tInputWidgets.commInitializer(this);\n",
       "    }\n",
       "    Button.prototype = Widget;\n",
       "\n",
       "    var Text = function (typ, id, init) {\n",
       "\tvar attr = { type:  \"text\",\n",
       "\t\t     placeholder: init.label,\n",
       "\t\t     value: init.value },\n",
       "\t    elem = createElem(\"input\", attr),\n",
       "\t    self = this;\n",
       "\tthis.getState = function () {\n",
       "\t    return elem.value;\n",
       "\t}\n",
       "\telem.onkeyup = function () {\n",
       "\t    self.sendUpdate();\n",
       "\t}\n",
       "\n",
       "\tthis.id = id;\n",
       "\tthis.elem = elem;\n",
       "\tthis.label = init.label;\n",
       "\n",
       "\tInputWidgets.commInitializer(this);\n",
       "    }\n",
       "    Text.prototype = Widget;\n",
       "\n",
       "    var Textarea = function (typ, id, init) {\n",
       "\tvar attr = { placeholder: init.label },\n",
       "\t    elem = createElem(\"textarea\", attr, init.value),\n",
       "\t    self = this;\n",
       "\tthis.getState = function () {\n",
       "\t    return elem.value;\n",
       "\t}\n",
       "\telem.onchange = function () {\n",
       "\t    self.sendUpdate();\n",
       "\t}\n",
       "\n",
       "\tthis.id = id;\n",
       "\tthis.elem = elem;\n",
       "\tthis.label = init.label;\n",
       "\n",
       "\tInputWidgets.commInitializer(this);\n",
       "    }\n",
       "    Textarea.prototype = Widget;\n",
       "\n",
       "    // RadioButtons\n",
       "    // Dropdown\n",
       "    // HTML\n",
       "    // Latex\n",
       "\n",
       "    var InputWidgets = {\n",
       "\tSlider: Slider,\n",
       "\tCheckbox: Checkbox,\n",
       "\tButton: Button,\n",
       "\tText: Text,\n",
       "\tTextarea: Textarea,\n",
       "\tdebug: false,\n",
       "\tlog: function () {\n",
       "\t    if (InputWidgets.debug) {\n",
       "\t\tconsole.log.apply(console, arguments);\n",
       "\t    }\n",
       "\t},\n",
       "\t// a central way to initalize communication\n",
       "\t// for widgets.\n",
       "\tcommInitializer: function (widget) {\n",
       "\t    widget.sendUpdate = function () {};\n",
       "\t}\n",
       "    };\n",
       "\n",
       "    window.InputWidgets = InputWidgets;\n",
       "\n",
       "})(jQuery, undefined);\n",
       "</script>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div id=\"interact-js-shim\">\n",
       "    <script charset=\"utf-8\">\n",
       "(function (IPython, $, _, MathJax, Widgets) {\n",
       "    $.event.special.destroyed = {\n",
       "\tremove: function(o) {\n",
       "\t    if (o.handler) {\n",
       "\t\to.handler.apply(this, arguments)\n",
       "\t    }\n",
       "\t}\n",
       "    }\n",
       "\n",
       "    var OutputArea = IPython.version >= \"4.0.0\" ? require(\"notebook/js/outputarea\").OutputArea : IPython.OutputArea;\n",
       "\n",
       "    var redrawValue = function (container, type, val) {\n",
       "\tvar selector = $(\"<div/>\");\n",
       "\tvar oa = new OutputArea(_.extend(selector, {\n",
       "\t    selector: selector,\n",
       "\t    prompt_area: true,\n",
       "\t    events: IPython.events,\n",
       "\t    keyboard_manager: IPython.keyboard_manager\n",
       "\t})); // Hack to work with IPython 2.1.0\n",
       "\n",
       "\tswitch (type) {\n",
       "\tcase \"image/png\":\n",
       "            var _src = 'data:' + type + ';base64,' + val;\n",
       "\t    $(container).find(\"img\").attr('src', _src);\n",
       "\t    break;\n",
       "\tdefault:\n",
       "\t    var toinsert = OutputArea.append_map[type].apply(\n",
       "\t\toa, [val, {}, selector]\n",
       "\t    );\n",
       "\t    $(container).empty().append(toinsert.contents());\n",
       "\t    selector.remove();\n",
       "\t}\n",
       "\tif (type === \"text/latex\" && MathJax) {\n",
       "\t    MathJax.Hub.Queue([\"Typeset\", MathJax.Hub, toinsert.get(0)]);\n",
       "\t}\n",
       "    }\n",
       "\n",
       "\n",
       "    $(document).ready(function() {\n",
       "\tWidgets.debug = false; // log messages etc in console.\n",
       "\tfunction initComm(evt, data) {\n",
       "\t    var comm_manager = data.kernel.comm_manager;\n",
       "        //_.extend(comm_manager.targets, require(\"widgets/js/widget\"))\n",
       "\t    comm_manager.register_target(\"Signal\", function (comm) {\n",
       "            comm.on_msg(function (msg) {\n",
       "                //Widgets.log(\"message received\", msg);\n",
       "                var val = msg.content.data.value;\n",
       "                $(\".signal-\" + comm.comm_id).each(function() {\n",
       "                var type = $(this).data(\"type\");\n",
       "                if (val[type]) {\n",
       "                    redrawValue(this, type, val[type], type);\n",
       "                }\n",
       "                });\n",
       "                delete val;\n",
       "                delete msg.content.data.value;\n",
       "            });\n",
       "\t    });\n",
       "\n",
       "\t    // coordingate with Comm and redraw Signals\n",
       "\t    // XXX: Test using Reactive here to improve performance\n",
       "\t    $([IPython.events]).on(\n",
       "\t\t'output_appended.OutputArea', function (event, type, value, md, toinsert) {\n",
       "\t\t    if (md && md.reactive) {\n",
       "                // console.log(md.comm_id);\n",
       "                toinsert.addClass(\"signal-\" + md.comm_id);\n",
       "                toinsert.data(\"type\", type);\n",
       "                // Signal back indicating the mimetype required\n",
       "                var comm_manager = IPython.notebook.kernel.comm_manager;\n",
       "                var comm = comm_manager.comms[md.comm_id];\n",
       "                comm.then(function (c) {\n",
       "                    c.send({action: \"subscribe_mime\",\n",
       "                       mime: type});\n",
       "                    toinsert.bind(\"destroyed\", function() {\n",
       "                        c.send({action: \"unsubscribe_mime\",\n",
       "                               mime: type});\n",
       "                    });\n",
       "                })\n",
       "\t\t    }\n",
       "\t    });\n",
       "\t}\n",
       "\n",
       "\ttry {\n",
       "\t    // try to initialize right away. otherwise, wait on the status_started event.\n",
       "\t    initComm(undefined, IPython.notebook);\n",
       "\t} catch (e) {\n",
       "\t    $([IPython.events]).on('kernel_created.Kernel kernel_created.Session', initComm);\n",
       "\t}\n",
       "    });\n",
       "})(IPython, jQuery, _, MathJax, InputWidgets);\n",
       "</script>\n",
       "    <script>\n",
       "        window.interactLoadedFlag = true\n",
       "       $(\"#interact-js-shim\").bind(\"destroyed\", function () {\n",
       "           if (window.interactLoadedFlag) {\n",
       "               console.warn(\"JavaScript required by Interact will be removed if you remove this cell or run using Interact more than once.\")\n",
       "           }\n",
       "       })\n",
       "       $([IPython.events]).on(\"kernel_starting.Kernel kernel_restarting.Kernel\", function () { window.interactLoadedFlag = false })\n",
       "   </script>\n",
       "</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "using Interact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "draw_image (generic function with 2 methods)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function draw_image(f, X, color=\"cyan\")\n",
    "    fig = figure()\n",
    "    @manipulate for n in 1:100\n",
    "        withfig(fig) do\n",
    "            input = split(X, n)\n",
    "            output = map(f, input)\n",
    "\n",
    "            draw(output, color, 0.1)\n",
    "            draw(input, \"grey\", 0.1)\n",
    "\n",
    "            axis(\"image\")\n",
    "        end\n",
    "    end\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "Interact.Slider{Int64}(Signal{Int64}(50, nactions=0),\"n\",50,1:100,true)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x31b3ae090>)"
      ]
     },
     "execution_count": 16,
     "metadata": {
      "comm_id": "7bd2ea2b-d96c-4149-8c83-1e706c1de67d",
      "reactive": true
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "draw_image(f, IntervalBox(0..1, 0..1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "standard_map (generic function with 2 methods)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function standard_map(X::IntervalBox, k = 1.0)\n",
    "    p, θ = X\n",
    "    \n",
    "    p′ = p + k*sin(θ)\n",
    "    θ′ = θ + p′\n",
    "    \n",
    "    IntervalBox(p′, θ′)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "iterate (generic function with 1 method)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function iterate(f, n, x)\n",
    "    for i in 1:n\n",
    "        x = f(x)\n",
    "    end\n",
    "    x\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "Interact.Slider{Int64}(Signal{Int64}(50, nactions=0),\"n\",50,1:100,true)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x31a0684d0>)"
      ]
     },
     "execution_count": 16,
     "metadata": {
      "comm_id": "8b4e951a-3075-447c-9edf-97e92c97655f",
      "reactive": true
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@manipulate for i in 1:10, j in 1:10\n",
    "\n",
    "i = 9\n",
    "j = 8\n",
    "\n",
    "#X = IntervalBox((i/10)*2pi..(i+1)/10*2pi, (j/10)*2pi..(j+1)/10*2pi)\n",
    "\n",
    "X = IntervalBox(0..6, 0..6)\n",
    "\n",
    "draw_image(x -> iterate(standard_map, 4, x), X)\n",
    "\n",
    "#axis([0, 2pi, 0, 2pi])\n",
    "    #axis(\"image\")\n",
    "#end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mod (generic function with 42 methods)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import Base.mod \n",
    "function mod(X::Interval, width::Real)\n",
    "    \n",
    "    \n",
    "    @show X, width\n",
    "\n",
    "    X /= width\n",
    "    \n",
    "    if diam(X) >= 1.\n",
    "        return [Interval(0, width)]\n",
    "    end\n",
    "    \n",
    "    a = X.lo - floor(X.lo)\n",
    "    b = X.hi - floor(X.hi)\n",
    "    \n",
    "    if a < b\n",
    "        return [Interval(a, b)*width]\n",
    "        \n",
    "    end\n",
    "    \n",
    "    return [Interval(0, b)*width, Interval(a, 1)*width]\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element Array{ValidatedNumerics.Interval{Float64},1}:\n",
       " [0.3, 0.5]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mod(Interval(0.3, 0.5), 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{ValidatedNumerics.Interval{Float64},1}:\n",
       " [0.0, 0.19999999999999996]\n",
       " [0.3, 1.0]                "
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mod(Interval(0.3, 1.2), 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element Array{ValidatedNumerics.Interval{Float64},1}:\n",
       " [0.0, 1.0]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mod(Interval(0.3, 1.5), 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mod (generic function with 42 methods)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function mod(X::IntervalBox, width::Real)\n",
    "    x, y = X\n",
    "    \n",
    "    xx = mod(x, width)\n",
    "    yy = mod(y, width)\n",
    "    \n",
    "    vec([IntervalBox(x, y) for x in xx, y in yy])\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element Array{Any,1}:\n",
       " IntervalBox([0.0, 0.5],[0.09999999999999999, 0.6000000000000001])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = IntervalBox(0..0.5, 0.1..0.6)\n",
    "mod(X, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Any,1}:\n",
       " IntervalBox([0.0, 0.5],[0.0, 0.10000000000000009])\n",
       " IntervalBox([0.0, 0.5],[0.8999999999999999, 1.0]) "
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = IntervalBox(0..0.5, 0.9..1.1)\n",
    "mod(X, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Any,1}:\n",
       " IntervalBox([0.0, 0.20000000000000018],[0.0, 0.20000000000000018])\n",
       " IntervalBox([0.7999999999999999, 1.0],[0.0, 0.20000000000000018]) \n",
       " IntervalBox([0.0, 0.20000000000000018],[0.7999999999999999, 1.0]) \n",
       " IntervalBox([0.7999999999999999, 1.0],[0.7999999999999999, 1.0])  "
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = IntervalBox(0.8..1.2, 0.8..1.2)\n",
    "mod(X, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{ValidatedNumerics.Interval{Float64},1}:\n",
       " [0.0, 0.7168146928204147]             \n",
       " [5.999999999999998, 6.283185307179587]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mod(6..7, ValidatedNumerics.two_pi(Float64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{ValidatedNumerics.Interval{Float64},1}:\n",
       " [0.0, 0.7168146928204147]             \n",
       " [5.999999999999998, 6.283185307179587]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mod(6..7, @interval(2π))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6.283185307179586, 6.283185307179587]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@interval(2π)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.283185307179586"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6.283185307179586, 6.283185307179587]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*@interval(pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.283185307179586"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7168146928204138"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 - ans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "standard_map (generic function with 2 methods)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function standard_map(X::IntervalBox, k = 1.0)\n",
    "    p, θ = X\n",
    "    \n",
    "    p′ = mod2pi( p + k*sin(θ) )\n",
    "    θ′ = mod2pi( θ + p′ )\n",
    "    \n",
    "    @show p′, θ′\n",
    "    \n",
    "    IntervalBox(p′, θ′)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ValidatedNumerics.IntervalBox{N,T}"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function IntervalBox{T}(X::Vector{Interval{T}}, Y::Vector{Interval{T}})\n",
    "    vec([IntervalBox(x, y) for x in X, y in Y])\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0, 1.0] × [0.0, 1.0]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = IntervalBox(0..1, 0..1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0, 1.8414709848078967]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p, theta = X\n",
    "p + sin(theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ValidatedNumerics.Interval{Float64}"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(p + sin(theta))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(X,width) = ([0.0, 1.8414709848078967],[6.283185307179586, 6.283185307179587])"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1-element Array{ValidatedNumerics.Interval{Float64},1}:\n",
       " [0.0, 1.8414709848078974]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "mod(p + sin(theta), ValidatedNumerics.two_pi(Float64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mod2pi (generic function with 2 methods)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mod2pi{T}(x::Interval{T}) = mod(x, ValidatedNumerics.two_pi(T))\n",
    "\n",
    "mod2pi{T}(X::Vector{Interval{T}}) = map(mod2pi, X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{ValidatedNumerics.Interval{Float64},1}:\n",
       " [0.0, 0.7168146928204147]             \n",
       " [5.999999999999998, 6.283185307179587]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mod2pi(6..7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6.283185307179586, 6.283185307179587]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ValidatedNumerics.two_pi(Float64)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(X,width) = ([0.0, 1.8414709848078967],[6.283185307179586, 6.283185307179587])"
     ]
    },
    {
     "ename": "LoadError",
     "evalue": "LoadError: MethodError: `convert` has no method matching convert(::Type{ValidatedNumerics.Interval{T}}, ::Array{ValidatedNumerics.Interval{Float64},1})\nThis may have arisen from a call to the constructor ValidatedNumerics.Interval{T}(...),\nsince type constructors fall back to convert methods.\nClosest candidates are:\n  call{T}(::Type{T}, ::Any)\n  convert{T<:Real}(::Type{T<:Real}, !Matched::Complex{T<:Real})\n  convert{T<:Number}(::Type{T<:Number}, !Matched::Char)\n  ...\nwhile loading In[84], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: MethodError: `convert` has no method matching convert(::Type{ValidatedNumerics.Interval{T}}, ::Array{ValidatedNumerics.Interval{Float64},1})\nThis may have arisen from a call to the constructor ValidatedNumerics.Interval{T}(...),\nsince type constructors fall back to convert methods.\nClosest candidates are:\n  call{T}(::Type{T}, ::Any)\n  convert{T<:Real}(::Type{T<:Real}, !Matched::Complex{T<:Real})\n  convert{T<:Number}(::Type{T<:Number}, !Matched::Char)\n  ...\nwhile loading In[84], in expression starting on line 1",
      "",
      " in call at /Users/dpsanders/.julia/v0.4/FixedSizeArrays/src/constructors.jl:92",
      " in standard_map at In[77]:9",
      " in standard_map at In[77]:2"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "(X,width) = ([0.0, 2.8414709848078976],[6.283185307179586, 6.283185307179587])\n",
      "(p′,θ′) = (ValidatedNumerics.Interval{Float64}[[0.0, 1.8414709848078974]],[ValidatedNumerics.Interval{Float64}[[0.0, 2.8414709848078985]]])\n"
     ]
    }
   ],
   "source": [
    "standard_map(IntervalBox(0..1, 0..1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element Array{ValidatedNumerics.Interval{Float64},1}:\n",
       " [0.0, 1.8414709848078974]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = [ValidatedNumerics.Interval{Float64}(0.0, 1.8414709848078974)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element Array{ValidatedNumerics.Interval{Float64},1}:\n",
       " [0.0, 2.8414709848078985]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta = [@interval(0.0, 2.8414709848078985)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element Array{ValidatedNumerics.IntervalBox{2,Float64},1}:\n",
       " IntervalBox([0.0, 1.8414709848078974],[0.0, 2.8414709848078985])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IntervalBox(p, theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mod2pi (generic function with 6 methods)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "include(\"standard_map.jl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "draw_image(standard_map, )"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.4.2",
   "language": "julia",
   "name": "julia-0.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.4.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
